home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2001 #11 / CD 11 (Black) - 2001.iso / FAVORG / FAVO_SRC.ZIP / StringExt.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  6.7 KB  |  273 lines
  1. // FAVORG Version 1.1
  2. // Copyright (c) 2000 Ziff Davis Media, Inc.
  3. // All rights reserved.
  4. // First Published in PC Magazine, US Edition, November 7, 2000.
  5. // Programmer: Patrick Philippot
  6.  
  7. #ifndef __CStringExt_H__
  8. #define __CStringExt_H__
  9.  
  10. // Includes
  11.  
  12. ////////////////////////////////////////////////////////////
  13. // Declaration of CStringEx
  14. ////////////////////////////////////////////////////////////
  15.  
  16. class CStringEx : public CString
  17. {
  18. //====== Constructors ======
  19. public:
  20.     CStringEx();
  21.     CStringEx(const CString& stringSrc) : CString(stringSrc) {}
  22.     CStringEx(TCHAR ch, int nRepeat = 1) : CString(ch, nRepeat) {}
  23.     CStringEx(LPCSTR lpsz) : CString(lpsz) {}
  24.     CStringEx(LPCWSTR lpsz) : CString(lpsz) {}
  25.     CStringEx(LPCTSTR lpch, int nLength) : CString(lpch, nLength) {}
  26.     CStringEx(const unsigned char* psz) : CString(psz) {}
  27.  
  28.     // overloaded assignment operator is not inherited from CString
  29.  
  30.     const CStringEx& operator=(const CString& stringSrc)
  31.         {CString::operator=(stringSrc); return *this;}
  32.     const CStringEx& operator=(TCHAR ch)
  33.         {CString::operator=(ch); return *this;}
  34. #ifdef _UNICODE
  35.     const CStringEx& operator=(char ch)
  36.         {CString::operator=(ch); return *this;}
  37. #endif
  38.     const CStringEx& operator=(LPCSTR lpsz)
  39.         {CString::operator=(lpsz); return *this;}
  40.     const CStringEx& operator=(LPCWSTR lpsz)
  41.         {CString::operator=(lpsz); return *this;}
  42.     const CStringEx& operator=(const unsigned char* psz)
  43.         {CString::operator=(psz); return *this;}
  44.  
  45. //====== Attributes ======
  46.  
  47. public:
  48.  
  49. protected:
  50.  
  51. private:
  52.  
  53.  
  54. //====== Operations ======
  55.  
  56. public:
  57.  
  58. // Inlines 
  59.  
  60.     CStringEx&    Delete(int nFirst, int nCount = INT_MAX);
  61.     CStringEx&    MakeCharUpper(int nIndex);
  62.     CStringEx&    MakeCharLower(int nIndex);
  63.     CStringEx&    AddSlash(void);
  64.     int            FirstNonSpace() const;
  65.     void        Trim();
  66.     int            FindNoCase(LPCTSTR lpszSub);
  67.  
  68.     //===== Classification functions =====
  69.     BOOL IsTab(int nIndex) const;
  70.     BOOL IsSpace(int nIndex) const;
  71.     BOOL IsAlpha(int nIndex) const;
  72.     BOOL IsAlNum(int nIndex) const;
  73.     BOOL IsBlank(int nIndex) const;
  74.     BOOL IsPunct(int nIndex) const;
  75.     BOOL IsUpper(int nIndex) const;
  76.     BOOL IsLower(int nIndex) const;
  77.     BOOL IsDigit(int nIndex) const;
  78.     BOOL IsHexDigit(int nIndex) const;
  79.  
  80. // Non-inlines
  81.  
  82.     CStringEx    ExpandTabs(int nTabIncr, BOOL bIgnoreQuotes = TRUE, int nMaxSize = INT_MAX);
  83.     CStringEx    CompressSpaces(int nTabIncr, BOOL bIgnoreQuotes);
  84.     CStringEx&    Insert(const CString sSource, int nPos);
  85.     CStringEx&    InsertChar(const TCHAR ch, int nPos);
  86.     CStringEx&    PadRight(const TCHAR ch, int nNewLen);
  87.     CStringEx&    PadLeft(const TCHAR ch, int nNewLen);
  88.     CStringEx&    Overlay(const CString sSource, int nPos);
  89.      CStringEx&    OverlayChar(const TCHAR ch, int nPos);
  90.     CStringEx&    Replace(CString sToken, CString sNewToken, int nMode, BOOL bCase = FALSE);
  91.     CStringEx&    StripSlash(void);
  92.     CStringEx&    RemoveQuotes();
  93.     CStringEx    URLDecode();
  94.  
  95.     //===== Path manipulation functions =====
  96.     static CString     FullPath(CString sRelPath);
  97.     static void        SplitPath(CString    const sPath, 
  98.                               CString&    sDrive, 
  99.                               CString&     sDir, 
  100.                               CString&    sName, 
  101.                               CString&    sExt,
  102.                               BOOL bIsDir = FALSE);
  103.     static CString     MakePath(CString sDrive, 
  104.                              CString sDir, 
  105.                              CString sName, 
  106.                              CString sExt);
  107.     CString GetExtension();
  108.     
  109.     CString&    StripToPath();
  110.     CStringEx&    ReplaceNameComponent(const CString sNewComponent, int nComponent);
  111.  
  112.     CStringEx    GetFirstToken(CString& sDelimiters, int nMaxLen = 255);
  113.     CStringEx    GetNextToken(CString& sDelimiters);
  114.     
  115.     //===== Conversion functions =====
  116.     CStringEx&    ItoA(int value, int radix = 10);
  117.     CStringEx&    LtoA(int value, CString sNum, int radix);
  118.     long        AtoL();
  119.     double        AtoD();
  120.  
  121. protected:
  122.  
  123. private:
  124.  
  125. //====== Overridables ======
  126.  
  127. //====== Implementation ======
  128. public:
  129.     virtual ~CStringEx();
  130.  
  131. protected:
  132.     LPTSTR MakeRoom(int nPos, int nExtra);
  133. private:
  134.  
  135. };
  136.  
  137. // Inlines
  138.  
  139. inline CStringEx& CStringEx::Delete(int nFirst, int nCount)
  140. {
  141.     *this = Left(nFirst) + Mid(nFirst + nCount);
  142.     
  143.     return (*this);
  144. }
  145.  
  146. inline CStringEx& CStringEx::MakeCharUpper(int nIndex)
  147. {
  148.     ASSERT(nIndex >= 0);
  149.     ASSERT(nIndex < GetLength());
  150.     SetAt(nIndex, (TCHAR) CharUpper((LPTSTR) GetAt(nIndex)));
  151.  
  152.     return (*this);
  153. }
  154.  
  155. inline CStringEx& CStringEx::MakeCharLower(int nIndex)
  156. {
  157.     ASSERT(nIndex >= 0);
  158.     ASSERT(nIndex < GetLength());
  159.  
  160.     SetAt(nIndex, (TCHAR) CharLower((LPTSTR) GetAt(nIndex)));
  161.  
  162.     return (*this);
  163. }
  164.  
  165. inline int CStringEx::IsTab (int nIndex) const
  166. {
  167.    ASSERT(nIndex >= 0);
  168.    ASSERT(nIndex < GetLength());
  169.    return GetAt(nIndex) == '\t';
  170. }
  171.  
  172. inline BOOL CStringEx::IsAlpha (int nIndex) const
  173. {
  174.    ASSERT(nIndex >= 0);
  175.    ASSERT(nIndex < GetLength());
  176.    return IsCharAlpha(GetAt(nIndex));
  177. }
  178.  
  179. inline BOOL CStringEx::IsAlNum (int nIndex) const
  180. {
  181.    ASSERT(nIndex >= 0);
  182.    ASSERT(nIndex < GetLength());
  183.    return IsCharAlphaNumeric(GetAt(nIndex));
  184. }
  185.  
  186. inline BOOL CStringEx::IsSpace (int nIndex) const
  187. {
  188.    ASSERT(nIndex >= 0);
  189.    ASSERT(nIndex < GetLength());
  190.    return _istspace(GetAt(nIndex));
  191. }
  192.  
  193. inline BOOL CStringEx::IsBlank (int nIndex) const
  194. {
  195.    ASSERT(nIndex >= 0);
  196.    ASSERT(nIndex < GetLength());
  197.    return GetAt(nIndex) == ' ';
  198. }
  199.  
  200. inline BOOL CStringEx::IsPunct (int nIndex) const
  201. {
  202.    ASSERT(nIndex >= 0);
  203.    ASSERT(nIndex < GetLength());
  204.    return _istpunct(GetAt(nIndex));
  205. }
  206.  
  207. inline BOOL CStringEx::IsUpper (int nIndex) const
  208. {
  209.    ASSERT(nIndex >= 0);
  210.    ASSERT(nIndex < GetLength());
  211.    return IsCharUpper(GetAt(nIndex));
  212. }
  213.  
  214. inline BOOL CStringEx::IsLower (int nIndex) const
  215. {
  216.    ASSERT(nIndex >= 0);
  217.    ASSERT(nIndex < GetLength());
  218.    return IsCharLower(GetAt(nIndex));
  219. }
  220.  
  221. inline BOOL CStringEx::IsDigit (int nIndex) const
  222. {
  223.    ASSERT(nIndex >= 0);
  224.    ASSERT(nIndex < GetLength());
  225.    return _istdigit(GetAt(nIndex));
  226. }
  227.  
  228. inline BOOL CStringEx::IsHexDigit (int nIndex) const
  229. {
  230.    ASSERT(nIndex >= 0);
  231.    ASSERT(nIndex < GetLength());
  232.    return _istxdigit(GetAt(nIndex));
  233.  }
  234.  
  235. inline CStringEx& CStringEx::AddSlash(void)
  236. // Adds a trailing slash if not present
  237. {
  238.     ASSERT(GetLength() > 0);
  239.  
  240.     if (GetAt(GetLength() - 1) != '\\')
  241.         *this += '\\';
  242.  
  243.     return (*this);
  244. }
  245.  
  246. inline int CStringEx::FirstNonSpace(void) const
  247. // Returns the index of the first non space character
  248. {
  249.     ASSERT(GetLength() > 0);
  250.  
  251.     int nIndex = -1;
  252.     while (IsSpace(++nIndex));
  253.     return(nIndex);
  254. }
  255.  
  256. inline void CStringEx::Trim()
  257. {
  258.     TrimLeft();
  259.     TrimRight();
  260. }
  261.  
  262. #define EX_STRING_REPDRIVE        0
  263. #define EX_STRING_REPDIR        1
  264. #define EX_STRING_REPNAME        2
  265. #define EX_STRING_REPEXT        3
  266. #define EX_STRING_REPFIRST        4
  267. #define EX_STRING_REPLAST        5
  268. #define EX_STRING_REPALL        6
  269.  
  270.  
  271. /////////////////////////////////////////////////////////////////////////////
  272. #endif // __CStringExt_H__
  273.